home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / Level 0 Macintosh 29Sep94 / Audit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  10.7 KB  |  438 lines  |  [TEXT/KAHL]
  1. /* Audit.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    System Dependency Library for Building Portable Software               */
  5. /*    Macintosh Version                                                      */
  6. /*    Written by Thomas R. Lawrence, 1993 - 1994.                            */
  7. /*                                                                           */
  8. /*    This file is Public Domain; it may be used for any purpose whatsoever  */
  9. /*    without restriction.                                                   */
  10. /*                                                                           */
  11. /*    This package is distributed in the hope that it will be useful,        */
  12. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  13. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                   */
  14. /*                                                                           */
  15. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  16. /*                                                                           */
  17. /*****************************************************************************/
  18.  
  19. #include "MiscInfo.h"
  20. #include "Audit.h"
  21. #include "Debug.h"
  22. #include "Definitions.h"
  23.  
  24. #ifdef THINK_C
  25.     #pragma options(pack_enums)
  26. #endif
  27. #include <Files.h>
  28. #ifdef THINK_C
  29.     #pragma options(!pack_enums)
  30. #endif
  31.  
  32.  
  33. #if AUDIT
  34.  
  35. typedef void *va_list;
  36. #define __va(arg)  &arg + 1
  37. #define va_start(p,arg)  p = __va(arg)
  38. #define va_arg(p, type)  *(*(type**)&p)++
  39. #define va_end(p)
  40.  
  41. static short                AuditRefNum;
  42. static MyBoolean        AuditInitialized = False;
  43.  
  44. static char                    Hex[16] = {'0','1','2','3','4','5','6','7',
  45.                                             '8','9','a','b','c','d','e','f'};
  46.  
  47. #pragma options(!mc68020) /* this code works no matter what */
  48.  
  49.  
  50. static void                    INITAUDIT(void)
  51.     {
  52.         unsigned char            FileName[] = {"\p!!Audit Trail"};
  53.  
  54.         FSDelete(FileName,0);
  55.         ERROR(Create(FileName,0,AUDITCREATOR,'TEXT') != noErr,
  56.             PRERR(ForceAbort,"Audit_Init couldn't create audit trail file."));
  57.         ERROR(FSOpen(FileName,0,&AuditRefNum) != noErr,
  58.             PRERR(ForceAbort,"Audit_Init couldn't open audit trail file for writing."));
  59.         AuditInitialized = True;
  60.     }
  61.  
  62.  
  63. void                                ENDAUDIT(void)
  64.     {
  65.         FSClose(AuditRefNum);
  66.     }
  67.  
  68.  
  69. static void                    FlushBuffer(char Buffer[1024], short* BufPtr, MyBoolean FlushAllFlag)
  70.     {
  71.         char*                            Place;
  72.         long                            Count;
  73.  
  74.         if ((*BufPtr >= 512) || (FlushAllFlag))
  75.             {
  76.                 Place = Buffer;
  77.                 while (*BufPtr != 0)
  78.                     {
  79.                         Count = *BufPtr;
  80.                         FSWrite(AuditRefNum,&Count,Place);
  81.                         *BufPtr -= Count;
  82.                         Place += Count;
  83.                     }
  84.             }
  85.     }
  86.  
  87.  
  88. #define COLUMNS (16)
  89. void                                AHEXDUMP(char* Ptr, long NumBytes)
  90.     {
  91.         while (NumBytes > 0)
  92.             {
  93.                 int                                Scan;
  94.                 char                            Buffer[1 + 3*COLUMNS + 1 + COLUMNS + 1];
  95.                 short                            Index;
  96.  
  97.                 Index = 0;
  98.                 Buffer[Index++] = 32;
  99.                 for (Scan = 0; Scan < COLUMNS; Scan += 1)
  100.                     {
  101.                         if (NumBytes > Scan)
  102.                             {
  103.                                 Buffer[Index++] = Hex[(((unsigned char*)Ptr)[Scan] >> 4) & 0x0f];
  104.                                 Buffer[Index++] = Hex[(((unsigned char*)Ptr)[Scan]) & 0x0f];
  105.                                 Buffer[Index++] = 32;
  106.                             }
  107.                          else
  108.                             {
  109.                                 Buffer[Index++] = 32;
  110.                                 Buffer[Index++] = 32;
  111.                                 Buffer[Index++] = 32;
  112.                             }
  113.                     }
  114.                 Buffer[Index++] = 32;
  115.                 for (Scan = 0; Scan < COLUMNS; Scan += 1)
  116.                     {
  117.                         if (NumBytes > Scan)
  118.                             {
  119.                                 if ((((unsigned char*)Ptr)[Scan] >= 32)
  120.                                     && (((unsigned char*)Ptr)[Scan] <= 126))
  121.                                     {
  122.                                         Buffer[Index++] = ((unsigned char*)Ptr)[Scan];
  123.                                     }
  124.                                  else
  125.                                     {
  126.                                         Buffer[Index++] = '.';
  127.                                     }
  128.                             }
  129.                          else
  130.                             {
  131.                                 Buffer[Index++] = 32;
  132.                             }
  133.                     }
  134.                 Buffer[Index++] = 13;
  135.                 FlushBuffer(Buffer,&Index,True/*force write*/);
  136.                 Ptr += COLUMNS;
  137.                 NumBytes -= COLUMNS;
  138.             }
  139.     }
  140.  
  141.  
  142. /* this prints a string in the same way that printf does.  it accepts these options: */
  143. /* %s = decimal signed short */
  144. /* $xs = hexadecimal short */
  145. /* %l = decimal signed long */
  146. /* %xl = hexadecimal long */
  147. /* %b = boolean from short */
  148. /* %c = decimal signed char */
  149. /* %xc = hexadecimal char */
  150. /* %t = C String (text) */
  151. /* %p = Pascal string */
  152. /* %r = Reference (a pointer) */
  153. void                                AuditPrint(char* Str,...)
  154.     {
  155.         va_list                        pa;
  156.         char                            Buffer[1024];
  157.         short                            BufPtr;
  158.         short                            VRefNum;
  159.  
  160.         if (!AuditInitialized)
  161.             {
  162.                 INITAUDIT();
  163.             }
  164.         BufPtr = 0;
  165.         va_start(pa,Str);
  166.         while (*Str != 0)
  167.             {
  168.                 if (*Str == '%')
  169.                     {
  170.                         MyBoolean                HexFlag;
  171.  
  172.                         Str += 1;
  173.                         HexFlag = (*Str == 'x');
  174.                         if (HexFlag)
  175.                             {
  176.                                 Str += 1;
  177.                             }
  178.                         switch (*Str)
  179.                             {
  180.                                 case 'r':
  181.                                     HexFlag = 1;
  182.                                     goto PrintLong; /* sizeof(pointer) == sizeof(long) on 68000 */
  183.                                 case 'l':
  184.                                     {
  185.                                         unsigned long        Num;
  186.  
  187.                                      PrintLong:
  188.                                         Num = va_arg(pa,long);
  189.                                         if (HexFlag)
  190.                                             {
  191.                                                 char                        Buf[9];
  192.                                                 short                        Count;
  193.  
  194.                                                 for (Count = 8; Count >= 1; Count -= 1)
  195.                                                     {
  196.                                                         Buf[Count] = Hex[Num & 0x0000000f];
  197.                                                         Num = Num >> 4;
  198.                                                     }
  199.                                                 Buf[0] = '$';
  200.                                                 for (Count = 0; Count < 9; Count += 1)
  201.                                                     {
  202.                                                         Buffer[BufPtr++] = Buf[Count];
  203.                                                     }
  204.                                             }
  205.                                          else
  206.                                             {
  207.                                                 char                        Buf[16];
  208.                                                 short                        BPtr;
  209.                                                 short                        Scan;
  210.  
  211.                                                 if (Num == -2147483648)
  212.                                                     {
  213.                                                         char        Apl[] = "-2147483648";
  214.                                                         short        Scan;
  215.  
  216.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  217.                                                             {
  218.                                                                 Buffer[BufPtr++] = Apl[Scan];
  219.                                                             }
  220.                                                     }
  221.                                                  else
  222.                                                     {
  223.                                                         if (Num < 0)
  224.                                                             {
  225.                                                                 Buffer[BufPtr++] = '-';
  226.                                                                 Num = -Num;
  227.                                                             }
  228.                                                         BPtr = 16;
  229.                                                         do
  230.                                                             {
  231.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  232.                                                                 Num = Num / 10;
  233.                                                             } while (Num != 0);
  234.                                                         for (Scan = BPtr; Scan < 16; Scan += 1)
  235.                                                             {
  236.                                                                 Buffer[BufPtr++] = Buf[Scan];
  237.                                                             }
  238.                                                     }
  239.                                             }
  240.                                     }
  241.                                     Str += 1;
  242.                                     break;
  243.                                 case 's':
  244.                                     {
  245.                                         unsigned short        Num;
  246.  
  247.                                         Num = va_arg(pa,short);
  248.                                         if (HexFlag)
  249.                                             {
  250.                                                 char                        Buf[5];
  251.                                                 short                        Count;
  252.  
  253.                                                 for (Count = 4; Count >= 1; Count -= 1)
  254.                                                     {
  255.                                                         Buf[Count] = Hex[Num & 0x000f];
  256.                                                         Num = Num >> 4;
  257.                                                     }
  258.                                                 Buf[0] = '$';
  259.                                                 for (Count = 0; Count < 5; Count += 1)
  260.                                                     {
  261.                                                         Buffer[BufPtr++] = Buf[Count];
  262.                                                     }
  263.                                             }
  264.                                          else
  265.                                             {
  266.                                                 if (Num == -32768)
  267.                                                     {
  268.                                                         char                        Apl[] = "-32768";
  269.                                                         short                        Scan;
  270.  
  271.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  272.                                                             {
  273.                                                                 Buffer[BufPtr++] = Apl[Scan];
  274.                                                             }
  275.                                                     }
  276.                                                  else
  277.                                                     {
  278.                                                         char                        Buf[8];
  279.                                                         short                        BPtr;
  280.                                                         short                        Scan;
  281.  
  282.                                                         if (Num < 0)
  283.                                                             {
  284.                                                                 Buffer[BufPtr++] = '-';
  285.                                                                 Num = -Num;
  286.                                                             }
  287.                                                         BPtr = 8;
  288.                                                         do
  289.                                                             {
  290.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  291.                                                                 Num = Num / 10;
  292.                                                             } while (Num != 0);
  293.                                                         for (Scan = BPtr; Scan < 8; Scan += 1)
  294.                                                             {
  295.                                                                 Buffer[BufPtr++] = Buf[Scan];
  296.                                                             }
  297.                                                     }
  298.                                             }
  299.                                     }
  300.                                     Str += 1;
  301.                                     break;
  302.                                 case 'c':
  303.                                     {
  304.                                         unsigned char        Num;
  305.  
  306.                                         Num = (va_arg(pa,short)) & 0x00ff;
  307.                                         if (HexFlag)
  308.                                             {
  309.                                                 char                        Buf[3];
  310.                                                 short                        Count;
  311.  
  312.                                                 for (Count = 2; Count >= 1; Count -= 1)
  313.                                                     {
  314.                                                         Buf[Count] = Hex[Num & 0x0f];
  315.                                                         Num = Num >> 4;
  316.                                                     }
  317.                                                 Buf[0] = '$';
  318.                                                 for (Count = 0; Count < 3; Count += 1)
  319.                                                     {
  320.                                                         Buffer[BufPtr++] = Buf[Count];
  321.                                                     }
  322.                                             }
  323.                                          else
  324.                                             {
  325.                                                 if (Num == -128)
  326.                                                     {
  327.                                                         char                        Apl[] = "-128";
  328.                                                         short                        Scan;
  329.  
  330.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  331.                                                             {
  332.                                                                 Buffer[BufPtr++] = Apl[Scan];
  333.                                                             }
  334.                                                     }
  335.                                                  else
  336.                                                     {
  337.                                                         char                        Buf[4];
  338.                                                         short                        BPtr;
  339.                                                         short                        Scan;
  340.  
  341.                                                         if (Num < 0)
  342.                                                             {
  343.                                                                 Buffer[BufPtr++] = '-';
  344.                                                                 Num = -Num;
  345.                                                             }
  346.                                                         BPtr = 4;
  347.                                                         do
  348.                                                             {
  349.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  350.                                                                 Num = Num / 10;
  351.                                                             } while (Num != 0);
  352.                                                         for (Scan = BPtr; Scan < 4; Scan += 1)
  353.                                                             {
  354.                                                                 Buffer[BufPtr++] = Buf[Scan];
  355.                                                             }
  356.                                                     }
  357.                                             }
  358.                                             Str += 1;
  359.                                             break;
  360.                                         case 't':
  361.                                             {
  362.                                                 char*                        Strp;
  363.  
  364.                                                 Strp = va_arg(pa,char*);
  365.                                                 while (*Strp != 0)
  366.                                                     {
  367.                                                         Buffer[BufPtr++] = *(Strp++);
  368.                                                         FlushBuffer(Buffer,&BufPtr,False);
  369.                                                     }
  370.                                             }
  371.                                             Str += 1;
  372.                                             break;
  373.                                         case 'p':
  374.                                             {
  375.                                                 char*                            Temp;
  376.                                                 short                            Scan;
  377.  
  378.                                                 Temp = va_arg(pa,char*);
  379.                                                 for (Scan = 0; Scan != Temp[0]; Scan += 1)
  380.                                                     {
  381.                                                         Buffer[BufPtr++] = Temp[Scan+1];
  382.                                                     }
  383.                                             }
  384.                                             Str += 1;
  385.                                             break;
  386.                                         case 'b':
  387.                                             {
  388.                                                 MyBoolean                Num;
  389.                                                 char*                        Strptr;
  390.                                                 short                        Cnt;
  391.  
  392.                                                 Num = va_arg(pa,MyBoolean);
  393.                                                 if (Num)
  394.                                                     {
  395.                                                         Strptr = "True";
  396.                                                     }
  397.                                                  else
  398.                                                     {
  399.                                                         Strptr = "False";
  400.                                                     }
  401.                                                 for (Cnt = 0; Strptr[Cnt] != 0; Cnt += 1)
  402.                                                     {
  403.                                                         Buffer[BufPtr++] = Strptr[Cnt];
  404.                                                     }
  405.                                             }
  406.                                             Str += 1;
  407.                                             break;
  408.                                         default:
  409.                                             {
  410.                                                 short                        Cnt;
  411.                                                 char                        Msg[] = "???";
  412.  
  413.                                                 for (Cnt = 0; Msg[Cnt] != 0; Cnt += 1)
  414.                                                     {
  415.                                                         Buffer[BufPtr++] = Msg[Cnt];
  416.                                                     }
  417.                                             }
  418.                                             Str += 1;
  419.                                             break;
  420.                                     }
  421.                             }
  422.                     }
  423.                  else
  424.                     {
  425.                         Buffer[BufPtr++] = *(Str++);
  426.                     }
  427.                 FlushBuffer(Buffer,&BufPtr,False);
  428.             }
  429.         Buffer[BufPtr++] = 0x0d;
  430.         FlushBuffer(Buffer,&BufPtr,True);
  431. #if AUDITFLUSHING
  432.         GetVRefNum(AuditRefNum,&VRefNum);
  433.         FlushVol("\p",VRefNum);
  434. #endif
  435.     }
  436.  
  437. #endif
  438.